#!/usr/bin/env python
# -*- coding: utf-8 -*-

import time
import random
import base64
import hmac
import hashlib
import struct
import io

def get_bytes(value):
    """
    模拟 com.ta.utdid2.a.a.d.getBytes 方法，将整数转换为字节数组
    """
    # 根据Java源码：
    # byte[] bArr = {(byte) ((r3 >> 8) % 256), (byte) (r3 % 256), (byte) (r3 % 256), (byte) (i2 % 256)};
    # int i3 = i2 >> 8;
    # int i4 = i3 >> 8;
    
    # 这里的实现有些奇怪，可能是反编译错误
    # 我们按照代码中实际使用的逻辑实现
    # 将32位整数转换为4个字节的大端序字节数组
    b0 = (value >> 24) & 0xFF
    b1 = (value >> 16) & 0xFF
    b2 = (value >> 8) & 0xFF
    b3 = value & 0xFF
    
    return bytes([b0, b1, b2, b3])

def string_hash(s):
    """
    模拟 com.ta.utdid2.a.a.f.a 方法，计算字符串的哈希值
    """
    # 根据Java源码：
    # int i2 = 0;
    # for (char c2 : str.toCharArray()) {
    #     i2 = (i2 * 31) + c2;
    # }
    # return i2;
    
    h = 0
    for c in s:
        h = (h * 31 + ord(c)) & 0xFFFFFFFF
    
    # 将无符号整数转换为有符号整数
    if h > 0x7FFFFFFF:
        h = h - 0x100000000
    
    return h

def encode_to_string(byte_array, flags=2):
    """
    模拟 com.ta.utdid2.a.a.b.encodeToString 方法，将字节数组编码为Base64字符串
    """
    # 根据Java源码，flags=2表示使用URL安全的Base64编码字符集，但不使用URL安全的编码方式
    # 查看b.java中的encode方法，我们可以看到：
    # 1. flags=2表示不使用填充字符
    # 2. flags=8表示使用URL安全的字符集（-_代替+/），但我们看到实际上没有使用这个标志
    
    # 使用标准的Base64编码，不添加填充字符
    return base64.b64encode(byte_array).decode('ascii').rstrip('=')

def generate_device_id():
    """
    模拟 com.ta.utdid2.device.c.c 方法，生成设备ID
    """
    # 创建一个字节数组输出流
    output = io.BytesIO()
    
    # 获取当前时间戳（秒级）
    current_time = int(time.time())
    
    # 生成一个随机数
    random_int = random.randint(-2147483648, 2147483647)
    
    # 将时间戳转换为字节
    time_bytes = get_bytes(current_time)
    
    # 将随机数转换为字节
    random_bytes = get_bytes(random_int)
    
    # 写入时间戳字节
    output.write(time_bytes)
    
    # 写入随机数字节
    output.write(random_bytes)
    
    # 写入版本号 (3)
    output.write(bytes([3]))
    
    # 写入保留字节 (0)
    output.write(bytes([0]))
    
    # 由于我们不获取设备信息，使用另一个随机数代替
    device_str = str(random.randint(-2147483648, 2147483647))
    device_hash = string_hash(device_str)
    device_hash_bytes = get_bytes(device_hash)
    
    # 写入设备哈希字节
    output.write(device_hash_bytes)
    
    # 获取当前输出流的字节数组，用于计算HMAC
    current_bytes = output.getvalue()
    
    # 计算HMAC
    # 原始Java代码中的密钥：
    # byte[] bArr2 = {69, 114, 116, -33, 125, -54, ExifInterface.MARKER_APP1, 86, -11, 11, -78, -96, -17, -99, 64, 23, -95, -126, -82, -64, 113, 116, -16, -103, 49, -30, 9, ExifInterface.MARKER_EOI, 33, -80, -68, -78, -117, 53, 30, -122, 64, -104, 74, -49, 106, 85, -38, -93};
    # 将Java中的有符号字节转换为Python中的无符号字节
    hmac_key = bytes([
        69, 114, 116, 223, 125, 202, 249, 86, 245, 11, 178, 160, 239, 157, 64, 23,
        161, 130, 174, 192, 113, 116, 240, 153, 49, 226, 9, 255, 33, 176, 188, 178,
        139, 53, 30, 134, 64, 152, 74, 207, 106, 85, 218, 163
    ])
    
    # 使用SHA1算法计算HMAC
    hmac_result = hmac.new(hmac_key, current_bytes, hashlib.sha1).digest()
    
    # 将HMAC结果编码为Base64字符串
    hmac_base64 = encode_to_string(hmac_result)
    
    # 计算HMAC Base64字符串的哈希值
    hmac_hash = string_hash(hmac_base64)
    hmac_hash_bytes = get_bytes(hmac_hash)
    
    # 写入HMAC哈希字节
    output.write(hmac_hash_bytes)
    
    # 获取最终的字节数组
    final_bytes = output.getvalue()
    
    # Base64编码
    encoded = encode_to_string(final_bytes)
    
    return encoded

def main():
    # 生成设备ID
    device_id = generate_device_id()
    print(f"生成的设备ID: {device_id}")
    print(f"长度: {len(device_id)}")
    print(f"示例设备ID: Z7LeH7vdDYcDAIYI3/TVXfAH")

if __name__ == "__main__":
    main()
